//package com.houger.jdk21;
//
//
//import com.houger.interfaces.JavaLanguage;
//import com.houger.interfaces.LanguageIf;
//import com.houger.jdk16.Outer;
//import com.houger.model.Hobby;
//import com.houger.model.Person;
//import com.houger.model.User;
//
//import java.net.URI;
//import java.net.URL;
//import java.net.http.HttpClient;
//import java.net.http.HttpRequest;
//import java.net.http.HttpResponse;
//import java.text.NumberFormat;
//import java.time.Duration;
//import java.util.*;
//import java.util.concurrent.*;
//import java.util.concurrent.atomic.AtomicInteger;
//import java.util.random.RandomGenerator;
//import java.util.random.RandomGeneratorFactory;
//import java.util.stream.Collectors;
//import java.util.stream.IntStream;
//import java.util.stream.Stream;
//
///**
// * 欢迎关注微信公众号：Java架构师之旅  一起学习交流
// */
//public class LearnJDK {
//    record Point(int i, int j) {}
//    enum Color { RED, GREEN, BLUE; }
//
//
//    static class TestJDK21{
//        static void typeTester(Object obj) {
//            switch (obj) {
//                case null     -> System.out.println("null");
//                case String s -> System.out.println("String");
//                case Color c  -> System.out.println("Color: " + c.toString());
//                case Point p  -> System.out.println("Record class: " + p.toString());
//                case int[] ia -> System.out.println("Array of ints of length" + ia.length);
//                default       -> System.out.println("Something else");
//            }
//        }
//    }
//
//    private static String handlePrint(String input){
//       if (input.isEmpty()){
//           return null;
//       }
//        System.out.println(STR."input=\{input}");
//        return "ok";
//    }
//    public static void main(String[] args){
//        jdk8();
//
//        jdk9();
//
//        jdk10();
//
//        jdk11();
//
//        jdk12();
//
//        jdk13();
//
//        jdk14(1);
//
//        jdk15();
//
//        jdk16();
//
//        jdk17();
//
//        jdk18();
//
//        jdk19();
//
//        jdk20();
//
//        jdk21();
//
//
//
//    }
//
//
//
//    private static void jdk21() {
//        System.out.println("==================================================jdk21新特性==============================================");
//
//        ScopedValue<String> key = ScopedValue.newInstance();
//        final ScopedValue.Carrier value = ScopedValue.where(key, "value");
//
//        // 虚拟线程
//        final long b = System.currentTimeMillis();
//        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
//
//            IntStream.range(0, 10).forEach(i -> {
//                executor.submit(() -> {
//                    Thread.sleep(Duration.ofSeconds(1));
//                    System.out.println("v="+value.get(key));
//                    System.out.println("========");
//                    return i;
//                });
//            });
//
//        }  // executor.close() is called implicitly, and waits
//        final long e = System.currentTimeMillis();
//        System.out.println("耗时："+(e-b)+"ms");
//
//        int count= 0 ;
//        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
//            var future1 = executor.submit(() -> handlePrint("你发任你发"));
//            var future2 = executor.submit(() -> handlePrint("劳资Java8"));
//
//            switch (future1.get()){
//                case "ok" -> count++;
//                case null -> System.out.println("future1 is not ok");
//                default -> throw new IllegalStateException("Unexpected");
//            }
//            switch (future2.get()){
//                case "ok" -> count++;
//                case null,default -> System.out.println("future2 is not ok");
//            }
//            assert count==2;
//            System.out.println(STR."count=\{count}");
//        } catch (ExecutionException | InterruptedException _) {
//
//        }
//
//
//
//        //Sequenced Collections
//        List list = new ArrayList();
//        list.add(1);
//        list.add(5);
//        list.add(3);
//        Object first = list.getFirst();
//        Object last = list.getLast();
//        System.out.println(STR."first=\{first}");
//        System.out.println(STR."last=\{last}");
//        System.out.println("=================反转============");
//        final List reversed = list.reversed();
//        Object first2 = reversed.getFirst();
//        Object last2 = reversed.getLast();
//        System.out.println(STR."first2=\{first2}");
//        System.out.println(STR."last2=\{last2}");
//
//        //        Record Patterns
//        record Pair(Object x, Object y) {}
//
//        Pair p = new Pair(42, 42);
//
//        if (p instanceof Pair(String s, String t)) {
//            System.out.println(s + ", " + t);
//        } else if (p instanceof Pair(Integer x, Integer y)) {
//            System.out.println(STR."x=\{x},y=\{y}");
//        } else {
//            System.out.println("Not a pair of strings");
//        }
//
//        //Pattern Matching for switch
//        TestJDK21.typeTester(new Point(1,2));
//        TestJDK21.typeTester(null);
//        TestJDK21.typeTester("");
//        TestJDK21.typeTester(Color.BLUE);
//        TestJDK21.typeTester(3.14);
//
//
//
//    }
//    private static void jdk20() {
//
//        System.out.println("==================================================jdk20新特性==============================================");
//        //作用域值 作用域值（Scoped Values）它可以在线程内和线程间共享不可变的数据，优于线程局部变量，尤其是在使用大量虚拟线程时。
//        final ScopedValue<Integer> v = ScopedValue.newInstance();
//        final Integer v1 = ScopedValue.where(v, 1).get(v);
//        System.out.println(v1);
//
//
//    }
//    private static void jdk19() {
//        System.out.println("==================================================jdk19新特性==============================================");
//
//        ExecutorService executor = Executors.newFixedThreadPool(4);
//        AtomicInteger count = new AtomicInteger(0);
//
//        try (StructuredTaskScope<Object> scope = new StructuredTaskScope<>();){
//            scope.fork(() -> {
//                int currentCount = count.incrementAndGet();
//                System.out.println("Task " + currentCount + " is running in scope " + scope);
//                return "ok";
//            });
//            scope.join();
//        } catch (InterruptedException e) {
//            throw new RuntimeException(e);
//        }
//        executor.shutdown();
//    }
//
//
//    private static void jdk18() {
//        System.out.println("==================================================jdk18新特性==============================================");
//        //在 Java 18 之前，如果我们想要在 Javadoc 中引入代码片段可以使用 <pre>{@code ...}</pre> 。
//        /**
//         *<pre>{@code
//         *     lines of source code
//         * }</pre>
//         */
//        // 在 Java 18 之后，可以通过 @snippet 标签来做这件事情。
//        /**
//         * The following code shows how to use {@code Optional.isPresent}:
//         * {@snippet :
//         * if (v.isPresent()) {
//         *     System.out.println("v: " + v.get());
//         * }
//         * }
//         */
//    }
//
//    private static void jdk17() {
//        System.out.println("==================================================jdk17新特性==============================================");
//
//        /**
//         * Java 17 将是继 Java 8 以来最重要的长期支持（LTS）版本，是 Java 社区八年努力的成果。Spring 6.x 和 Spring Boot 3.x ,Spring Cloud 2022.X最低支持的就是 Java 17。
//         */
//
//        //        增强的伪随机数生成器
//        RandomGeneratorFactory<RandomGenerator> l128X256MixRandom = RandomGeneratorFactory.of("L128X256MixRandom");
//        // 使用时间戳作为随机数种子
//        RandomGenerator randomGenerator = l128X256MixRandom.create(System.currentTimeMillis());
//        // 生成随机数
//        for (int i = 0; i < 10; ++i) {
//            System.out.println(randomGenerator.nextInt(4));
//        }
//
//    }
//
//    private static void jdk16() {
//        System.out.println("==================================================jdk16新特性==============================================");
//        //从 Java 16 开始，你可以对 instanceof 中的变量值进行修改。
//        String o = "";
//        // 原来
//        if (o instanceof String) {
//            String s = (String) o;
//        }
//        Object c = null;
//        c = "";
//        // 新的
//        if (c instanceof String b) {
//            b = "b";
//            System.out.println("c=" + c);
//            System.out.println("b=" + b);
//        }
//
////        从 Java SE 16 开始，非静态内部类可以定义非常量的静态成员。
//
//        final Outer outer = new Outer(1);
//        final int innerAge = outer.getInnerAge();
//        System.out.println("innerAge="+innerAge);
//    }
//
//    private static void jdk15() {
//        System.out.println("==================================================jdk15新特性==============================================");
////          TreeMap 新引入了下面这些方法：
////        final TreeMap treeMap = new TreeMap();
////        treeMap.putIfAbsent();
////        treeMap.computeIfAbsent()
////        treeMap.computeIfPresent()
////        treeMap.compute()
////        treeMap.merge()
////        ZGC 默认的垃圾回收器依然是 G1。你可以通过下面的参数启动 ZGC：
//        //java -XX:+UseZGC className
//    }
//
//    private static void jdk14(Integer type) {
//        System.out.println("==================================================jdk14新特性==============================================");
//        //空指针异常精准提示 通过 JVM 参数中添加-XX:+ShowCodeDetailsInExceptionMessages，可以在空指针异常中获取更为详细的调用信息，更快的定位和解决问题。
////        User user = null;
////        final String name = user.getName();
////        System.out.println(name);
//
//        //switch 的增强(转正)
//        String x = switch (type){
//            case 1 -> {
//                System.out.println("1");
//                yield "one";
//            }
//            case 2 -> {
//                System.out.println("2");
//                yield "two";
//            }
//            default -> {
//                System.out.println("default");
//                yield "default";
//            }
//        };
//        System.out.println(x);
//    }
//
//    private static void jdk13() {
//        System.out.println("==================================================jdk13新特性==============================================");
//        //SocketAPI 重构
//        /**
//         * Java 13 将 Socket API 的底层进行了重写， NioSocketImpl 是对 PlainSocketImpl 的直接替代，
//         * 它使用 java.util.concurrent 包下的锁而不是同步方法。如果要使用旧实现，请使用 -Djdk.net.usePlainSocketImpl=true。
//         * 并且，在 Java 13 中是默认使用新的 Socket 实现。
//         */
//        // NioSocketImpl
//        //FileSystems 类中添加了以下三种新方法，以便更容易地使用将文件内容视为文件系统的文件系统提供程序：
//        //newFileSystem(Path)
//        //newFileSystem(Path, Map<String, ?>)
//        //newFileSystem(Path, Map<String, ?>, ClassLoader)
//
//    }
//
//    private static void jdk12() {
//        System.out.println("==================================================jdk12新特性==============================================");
//
//        //java12新特性
//        //数字格式化工具类  NumberFormat 新增了对复杂的数字进行格式化的支持
//        NumberFormat fmtShort = NumberFormat.getCompactNumberInstance(Locale.CHINESE, NumberFormat.Style.SHORT);
//        String resultShort = fmtShort.format(10000000);
//        System.out.println(resultShort);
//
//        NumberFormat fmt2Short = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
//        String result2Short = fmt2Short.format(10000000);
//        System.out.println(result2Short);
//
//        NumberFormat fmtLong = NumberFormat.getCompactNumberInstance(Locale.CHINESE, NumberFormat.Style.LONG);
//        String resultLong = fmtLong.format(10000000);
//        System.out.println(resultLong);
//
//        NumberFormat fmt2Long = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.LONG);
//        String result2Long = fmt2Long.format(10000000);
//        System.out.println(result2Long);
//
//        System.out.println("==================================================字符串缩进==============================================");
//
//        //String 增强  Java 11 增加了两个的字符串处理方法
//        //indent() 方法可以实现字符串缩进。
//        var a="a";
//        var b="b";
//        final String a1 = a.indent(8);
//        final String b1 = b.indent(8);
//        System.out.println(a1);
//        System.out.println(b1);
//        //transform() 方法可以用来转变指定字符串。
//        final String ab = a.transform((input) -> input + b);
//        System.out.println(ab);
//
//        // mismatch() 方法用于比较两个文件，并返回第一个不匹配字符的位置，如果文件相同则返回 -1L。
//        //public static long mismatch(Path path, Path path2) throws IOException
//    }
//
//    private static void jdk8() {
//
//        new Thread(()->{
//            System.out.println("Lambda 表达式");
//        },"t1").start();
//
//        final long count = Stream.of(1, 2, 3, 4, 5, 6)
//            .filter(x -> x > 1)
//            .count();
//        System.out.printf("count=%d\n",count);
//
//        final Integer max = List.of(1, 2, 3, 4, 5, 6).parallelStream()
//            .max(Integer::compareTo).orElseGet(()->0);
//        System.out.println("max="+max);
//
//        Person person = new Person(new Hobby("编程"));
//        // jdk8之前
//        if (person != null) {
//            final Hobby hobby = person.getHobby();
//            if (hobby != null) {
//                System.out.println(hobby.getDetail());
//            }
//        }
//        System.out.println("==================================================java8新特性==============================================");
//
//        System.out.println("==================================================Optional==============================================");
//        // Optional 更加优雅
//        Optional.of(person)
//            .map(Person::getHobby)
//            .map(Hobby::getDetail)
//            .ifPresent(System.out::println);
//        System.out.println("==================================================Interface==============================================");
//        //        Interface
//        LanguageIf.staticMethod();
//        LanguageIf javaLanguage = new JavaLanguage();
//        javaLanguage.defaultMethod();
//        final String languageType = javaLanguage.getLanguageType();
//        System.out.println(languageType);
//
//        System.out.println("==================================================Functional Interface==============================================");
//        //        functional interface 函数式接口
//        final User user = javaLanguage.functionMethod("张三丰", "写Java代码", User::new);
//        System.out.println(user);
//
//    }
//
//    private static void jdk9() {
//        System.out.println("==================================================java9新特性==============================================");
//        /**
//         * String 存储结构优化
//         * Java 8 及之前的版本，String 一直是用 char[] 存储。在 Java 9 之后，String 的实现改用 byte[] 数组存储字符串，节省了空间。
//         */
//        System.out.println("==================================================快速创建不可变集合==============================================");
//        //        快速创建不可变集合
//        final List<Integer> integers = List.of(1, 2, 3, 4);
//        final Set<String> strings = Set.of("1", "2", "3");
//        final Map<String, String> map = Map.of("k1", "v1");
//        System.out.println(integers);
//        System.out.println(strings);
//        System.out.println(map);
//
//    }
//
//    private static void jdk10() {
//        System.out.println("==================================================java10新特性==============================================");
//        //        java10新特性
//        System.out.println("==================================================局部变量类型推断(var)==============================================");
//        //        局部变量类型推断(var)   var不能声明为 null,不能声明为 Lambda表达式。
//        var num = 0;
//
//        try {
//            var url = new URL("https://qq.com");
//            var list2 = new ArrayList<>();
//
//            var map2 = new HashMap<String, String>();
//
//            list2.add(num);
//            list2.add(url);
//            list2.add(map2);
//            for (var n : list2){
//                System.out.print(n+ " ");
//            }
//        }catch (Exception e){
//
//        }
//
//
//
//    }
//
//    private static void jdk11() {
//        System.out.println("==================================================java11新特性==============================================");
//        //        java11新特性
//        System.out.println("==================================================HTTP Client 标准化==============================================");
//        //        HTTP Client 标准化
//        var request = HttpRequest.newBuilder()
//            .uri(URI.create("https://www.baidu.com/"))
//            .GET()
//            .build();
//        var client = HttpClient.newHttpClient();
//
//        // 同步
//        //        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
//        //        System.out.println(response.body());
//        // 异步
//        final CompletableFuture<Void> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
//            .thenApply(HttpResponse::body)
//            .thenAccept(System.out::println);
//        try {
//            future.get();
//        }catch (Exception e){
//            System.out.println(e.getMessage());
//        }
//
//        //String 增强
//        //判断字符串是否为空
//        System.out.println(" ".isBlank());
//        // 去除字符串首尾空格
//        System.out.println("结果:"+" 去除字符串首尾空格 ".strip()+"结束");
//        // 去除字符串首部空格
//        System.out.println("结果:"+"去除字符串首部空格 ".stripLeading()+"结束");
//        // 去除字符串尾部空格
//        System.out.println("结果:"+" 去除字符串尾部空格 ".stripTrailing()+"结束");
//        // 重复字符串多少次
//        System.out.println(" 重复字符串多少次 ".repeat(2));
//        // 返回由行终止符分隔次数。
//        System.out.println("A\nB\nC".lines().count());
//        // 返回由行终止符分隔的字符串集合。
//        System.out.println("A\nB\nC".lines().collect(Collectors.toList()));
//
//        //        Optional 增强
//        var obj= Optional.empty();
//        //判断指定的 Optional 对象是否为空
//        System.out.println(obj.isEmpty());
//        //        Java11 开始允许开发者在 Lambda 表达式中使用 var 进行参数声明。
//
//    }
//}